use Switch;

# IMPORTANTE: VARIABLES GLOBALES: $IDPais, %filtros, variables del localtime, paths de los maestros y prestamos, %regs, %meses.

sub consultas {
	my ($pathSalida) = @_;
	# Caso: coloco la opcion "-w" y en $pathSalida esta el path del archivo en el cual escribir.
	if ($pathSalida ne "" ) {
		open (STDOUT, "| tee -ai $pathSalida");
	}
	
	# Se almacenan en las variables, los paths de los archivos maestros.
	&almacenarPathMaestros;

	# Pedido de ingreso de pais al usuario.
	my ($pais) = &solicitarPais;
	# El pais no puede ser modificado, solo pueden modificarse los filtros y las consultas.

	# Almaceno el path del archivo de prestamos.<pais>
	$pathPrestamos = &buscarPrestamos($IDPais);

	# Obtengo los datos del sistema, los cuales seran usados en todo el script.
	($seg,$min,$hora,$diaActual,$mesActual,$anioActual,$diaSem,$diaAnio,$horaVerano) = localtime;
	$anioActual += 1900;
	$mesActual++;

	# Inicia el menu de ingreso de la consulta deseada.
	&cicloConsulta;

	if ($pathSalida ne "" ) {
		close(STDOUT);
	}
}

#------------------------------------------------------------------------------

# Almacena en las variables globales $pathPS y $pathPPI, los paths de los archivos maestros correspondientes.
sub almacenarPathMaestros {
	$pathPS = $ENV{MAEDIR} . "/P-S.mae";
	$pathPPI = $ENV{MAEDIR} . "/PPI.mae";
}

# Recibe como parametro el IDPais, es decir, la inicial del pais.
# Devuelve el path del archivo PRESTAMOS.<pais>, segun el pais pasado como parametro.
# NO verifica que exista el archivo. 
sub buscarPrestamos {
	my ($path);
	my ($pais) = @_;
	$path = $ENV{PROCDIR} . "/PRESTAMOS." . $pais;
	return($path);
}

# Solicita al usuario ingresar el nombre del pais sobre el cual hacer consultas.
# En caso de ingresar un pais que no exista en el archivo maestro P-S.mae, se seguira solicitando al usuario el ingreso del pais.
# Devuelve el pais ingresado, de forma estandarizada.
sub solicitarPais {
	my ($paisIngresado, $existePais);
	my ($salirPais) = "false";
	while ($salirPais eq "false") {
		print "Ingrese el nombre del pais sobre el cual hacer las consultas: ";
		$paisIngresado = <STDIN>;
		chop ($paisIngresado);
		# Estandarizo el paisIngresado segun como aparece en el archivo maestro P-S.mae.
		$paisIngresado = &estandarizarPais($paisIngresado);
		print "\nEl pais ingresado es: $paisIngresado \n";		
		# Verifico que el paisIngresado exista en el archivo maestro P-S.mae.
		$existePais = &obtenerIDPais($paisIngresado);
		if ($existePais eq "true") {
			$salirPais = "true";
		}
	}
	return ($paisIngresado);
}

# Estandariza el pais ingresado por el usuario de la forma: primer letra mayuscula, y el resto minuscula.
# Ademas, quita los acentos en caso de ingresarlos el usuario.
# Recibe el pais ingresado.
# Devuelve el pais estandarizado.
sub estandarizarPais {
	my($pais) = @_;
	# Se quitan los acentos, en caso de ingresarlos.
	$pais =~ s/á/a/g;
	$pais =~ s/é/e/g;
	$pais =~ s/í/i/g;
	$pais =~ s/ó/o/g;
	$pais =~ s/ú/u/g;

	$pais = lc ($pais);
	$primerLetra = uc ( substr ($pais,0,1) );
	$resto = substr ($pais,1,);
	$pais = $primerLetra . $resto;
	return($pais);
}

# Setea la variable global IDPais, segun el pais ingresado por el usuario.
# Verifica que el pais exista en el archivo maestro P-S.mae.
# Recibe el pais ingresado.
# Devuelve true o false en caso de que exista o no respectivamente.
sub obtenerIDPais {
	my ($paisIngresado) = @_;
	my ($existePais) = "false";
	if ($paisIngresado =~ /^[a-zA-Z]+$/ ) {
		# Se obtiene el ID del pais ingresado desde el archivo que esta en $pathPS
		open (PS, "<$pathPS") || die "ERROR: No se pudo abrir el archivo $pathPS \n";
		@lineaPS = <PS>;	
		foreach (@lineaPS) {	
			# Formato: IDPais-PaisDesc-IDSistema-SistDesc
			if ($_ =~ /-$paisIngresado-/ ) {
				@regPS = split ("-", $_);
				$IDPais = @regPS[0];
				$existePais = "true";
			}		
		};
		if ($existePais eq "false") {
			print "ERROR: El pais ingresado no existe en los archivos maestros. \n";		
		}
		close(PS);
	}
	else {
		print "ERROR: El pais ingresado debe tener caracteres alfabeticos. \n";
	}
	return($existePais);
}

# Realiza el ciclo de la consulta: solicita filtros, filtra, calcula montos restantes y solicita consulta.
# Sigue en el ciclo, hasta que el usuario no desee hacer mas consultas.
# NO recibe NI devuelve nada.
sub cicloConsulta {
	my ($opcion, $consulta, $valor, @montosMae, @montosPres, @codPres);
	# Se crea el hash con los meses. Sera consultado para validaciones en filtros.
	&crearHashMeses;
	my ($pregCambiarF) = "¿Desea cambiar los filtros aplicados? (S-N): ";
	my ($pregCambiarC) = "¿Desea cambiar la consulta seleccionada? (S-N): ";
	my ($pregOtraC) = "¿Desea realizar otra consulta? (S-N): ";
	my ($opcionC) = "s";
	my ($opcionF) = "s";
	my($salir) = "false";
	# Se sale del while SOLO cuando el usuario no desee hacer mas consultas.
	while ($salir eq "false") {
		# Verifico si el usuario desea cambiar los filtros (la 1era vez entra obligatoriamente).
		if ($opcionF eq "s") {		
			&solicitarFiltros;
			&filtrar;
			@montosMae = &calcularMontosRestantes("maestro");
			@montosPres = &calcularMontosRestantes("prestamos");
			# Los codigos de prestamos se obtienen de prestamos.<pais>
			@codPres = &obtenerCodigoPrestamo;
		
			# Guardo los datos obtenidos en %regs. Por cada clave, tengo un array de la forma (regPrestamos, montoMae, montoPres, codPres)
			my ($i) = 0;	
			foreach my $clave (keys(%regs)) {
				my (@vector) = ($regs{$clave}, sprintf("%.2f", $montosMae[$i]), sprintf("%.2f", $montosPres[$i]), $codPres[$i]);
				$regs{$clave} = [@vector];
				$i++;
			};
		}
		# Verifico si el usuario desea cambiar la consulta (la 1era vez entra obligatoriamente).
		if ($opcionC eq "s") {
			($consulta, $valor) = &solicitarConsulta;
		}
		# Verifico si existen registros en el maestro, con los filtros ingresados.
		if (%regs) {
			# Como existen registros, realizo la consulta ingresada.
			if ( $consulta eq "a" ) {
				&recalculo;			
			}
			else {
				if ( $consulta eq "b" ) {
					&difPorcentaje($valor);
				}
				else {
					&difMonto($valor);
				}
			}
		}
		else {
			print "No se encontraron registros para realizar consultas. \n";
		}
		# Consulto si desea realizar otra consulta.
		$opcion = &cicloSiNo ($pregOtraC);
		if ($opcion eq "n") {
			$salir = "true";
		}
		else {
			# Vacio las variables para una nueva consulta
			%regsRecalculo = ();
			# Consulto si desea modificar los filtros.
        	        $opcionF = &cicloSiNo ($pregCambiarF);
			# Consulto si desea modificar la consulta.
                        $opcionC = &cicloSiNo ($pregCambiarC);
	                if ($opcionF eq "s") {
        	                %filtros = ();
				%regs = ();
	                }
		}
	}
}

# Crea el hash global %meses, donde las claves son los nombres de los meses o numeros de los meses.
# Los valores del hash son los numeros de los meses 1..12.
# Para los nombres, es una transformacion nombre a numero. Para numero, es una transformacion identidad.
# Ademas, se utiliza para verificar que existe el mes.
sub crearHashMeses {
	my (@mesesV) = ("enero", "febrero", "marzo", "abril", "mayo", "junio", "julio", "agosto", "septiembre", "octubre", "noviembre", "diciembre");
	@meses{ @mesesV } = 1..$#mesesV+1;
	my ($i);
	for ($i = 1; $i <= 12; $i++) {
		$meses{ $i } = $i;
	}
}

# Sigue en el ciclo hasta que la opcion sea S,s,N o n.
# Recibe la pregunta que el usuario debe contestar.
# Devuelve la respuesta del usuario.
sub cicloSiNo {
	my ($pregunta) = @_;
	my ($opcion);
	my ($salir) = "false";
	while ($salir eq "false") {
		print $pregunta;
		$opcion = <STDIN>;
		chop($opcion);
		print "\nLa opcion ingresada es: $opcion \n";
		if ($opcion eq "s" || $opcion eq "S" || $opcion eq "N" || $opcion eq "n") {
			$salir = "true";
			$opcion = lc ($opcion);
		}
		else {
			print "Opcion incorrecta. \n";
		}
	}
	return ($opcion);
}

# Ciclo donde se solicitan todos los filtros al usuario. No se sale hasta que el usuario no este seguro de los filtros seleccionados.
# NO recibe NI devuelve nada.
sub solicitarFiltros {
	my ($opcion, $opcionSN, $opcionSNNin);
	my ($pregOtroF) = "¿Desea seleccionar otro filtro? (S-N): ";
	my ($pregSeguroNinguno) = "¿Esta seguro que desea borrar los filtros ingresados y no aplicar filtros? (S-N): ";
	my ($pregSeguroSalir) = "¿Esta seguro que desea aplicar los filtros ingresados? (S-N): ";
	my ($salirSeguro) = "false";
	# Sigue el ciclo hasta que el usuario este seguro de aplicar los filtros ingresados.
	while ($salirSeguro eq "false") {
		my ($salir) = "false";
		# Sigue el ciclo hasta que el usuario no desee seleccionar mas filtros.
		while ($salir eq "false") {
			# Se solicita un filtro entre Sistema, Anio, Periodo, Rango de Periodos o Ninguno.
			$opcion = &cicloFiltro;
			# Si la opcion no es Ninguno, se pregunta si desea seleccionar otro filtro.
			if ($opcion ne "e") {		
				$opcionSN = &cicloSiNo ($pregOtroF);	
				if ($opcionSN eq "n") {
					$salir = "true";
				}
			}
			# Si la opcion es Ninguno.
			else {
				# Si se selecciono uno o dos filtros anteriormente, se pregunta si esta seguro que desea borrar los filtros seleccionados.
				if (exists($filtros{"ID_Sistema"}) || exists($filtros{"Anio"}) || exists($filtros{"Anio_de_Periodo"}) || exists($filtros{"Anio_Inicial_de_Rango_de_Periodos"})) {
					$opcionSNNin = &cicloSiNo ($pregSeguroNinguno);			
					if ($opcionSNNin eq "s") {
						%filtros=();
						$salir = "true";
					}
				}
				# Si no se selecciono ningun filtro anteriormente, se sale del ciclo de solicitud de filtros.
				else {
					%filtros = ();
					$salir = "true";
				}
			}
		}
		# Se imprimen los filtros seleccionados.
		&imprimirFiltros();
		# Se pregunta si esta seguro de aplicar los filtros.
		$opcionSNSeguro = &cicloSiNo ($pregSeguroSalir);
		# Si esta seguro, se sale del ciclo.
		if ($opcionSNSeguro eq "s") {
			$salirSeguro = "true";
		}
		# Si no esta seguro, se borran los filtros y se ingresa nuevamente al ciclo de solicitud.
		else {
			%filtros = ();
		}
	}
}

# Ciclo donde se solicita y almacena un filtro mostrando las opciones correspondientes. Setea la variable global %filtros.
# NO recibe parametros.
# Devuelve la opcion del filtro seleccionado.
sub cicloFiltro {
	my($opcion);
	my ($salir) = "false";
	while ($salir eq "false") {
		print "A continuacion se enunciaran los filtros opcionales: \n";
		print "	a) Por codigo de sistema. \n";
		print "	b) Por anio. \n";
		print "	c) Por periodo. \n";
		print "	d) Por rango de periodos. \n";
		print "	e) Ninguno. \n";
		print "Ingrese el filtro elegido (a-b-c-d-e): ";
		$opcion = <STDIN>;
		chop($opcion);
		print "\nLa opcion ingresada es: $opcion \n";
		if ($opcion eq "a" || $opcion eq "A" || $opcion eq "b" || $opcion eq "B" || $opcion eq "c" || $opcion eq "C" || $opcion eq "d" || $opcion eq "D" || $opcion eq "e" || $opcion eq "E") {
			$opcion = lc ($opcion);
			$salir = "true";
		}
		else {
			print "Opcion de filtro incorrecta. \n";			
		}
	}
	# Segun el filtro seleccionado, se solicita el ingreso del valor del mismo.
	switch ($opcion) {
		case "a" {
			my ($pregSist) = "Ingrese el codigo del sistema por el cual realizar el filtro: ";
			my ($sist) = &solicitarSistema($pregSist);
			$filtros{"ID_Sistema"} = $sist;
		}
		case "b" { 
			if (exists($filtros{"Anio_de_Periodo"}) || exists($filtros{"Anio_Inicial_de_Rango_de_Periodos"})) {
				print "ERROR: No puede filtrarse por anio, ya que fue seleccionado otro filtro temporal. \n";
			}
			else {
				my ($preg) = "Ingrese el anio por el cual realizar el filtro: ";
				my ($anio) = &solicitarAnio($preg);
				$filtros{"Anio"} = $anio;
			}
		}
		case "c" {
			if (exists($filtros{"Anio"}) || exists($filtros{"Anio_Inicial_de_Rango_de_Periodos"})) {
				print "ERROR: No puede filtrarse por periodo, ya que fue seleccionado otro filtro temporal. \n";
			}
			else {
				my ($pregAnio) = "Ingrese el anio del periodo por el cual realizar el filtro: ";
			        my ($pregMes) = "Ingrese el numero o nombre del mes del periodo por el cual realizar el filtro: ";
				my ($anioPeriodo, $mesPeriodo) = &solicitarPeriodo($pregAnio, $pregMes);
				$filtros{"Anio_de_Periodo"} = $anioPeriodo;
				$filtros{"Mes_de_Periodo"} = $mesPeriodo;
			}
		}
		case "d" {
			if (exists($filtros{"Anio"}) || exists($filtros{"Anio_de_Periodo"})) {
				print "ERROR: No puede filtrarse por rango de periodos, ya que fue seleccionado otro filtro temporal. \n";
			}
			else {
				my ($pregAnioIni) = "Ingrese el anio del periodo inicial por el cual realizar el filtro: ";
				my ($pregMesIni) = "Ingrese el numero o nombre del mes del periodo inicial por el cual realizar el filtro: ";
				my ($pregAnioFin) = "Ingrese el anio del periodo final por el cual realizar el filtro: ";
				my ($pregMesFin) = "Ingrese el numero o nombre del mes del periodo final por el cual realizar el filtro: ";
				my ($anioIni, $mesIni, $anioFin, $mesFin) = &solicitarRangoPeriodo($pregAnioIni, $pregMesIni, $pregAnioFin, $pregMesFin);
				$filtros{"Anio_Inicial_de_Rango_de_Periodos"} = $anioIni;
				$filtros{"Mes_Inicial_de_Rango_de_Periodos"} = $mesIni;
				$filtros{"Anio_Final_de_Rango_de_Periodos"} = $anioFin;
				$filtros{"Mes_Final_de_Rango_de_Periodos"} = $mesFin;
			}
		}
		else {
		}
	}
	return($opcion);	
}

# Ciclo donde se solicita al usuario ingresar el codigo del sistema por el cual filtrar.
# En caso de ingresar un codigo de sistema que no exista en el archivo maestro P-S.mae, se seguira solicitando al usuario el ingreso del codigo del sistema.
# Recibe la pregunta a realizar.
# Devuelve el codigo del sistema ingresado.
# Se valida que el codigo del sistema exista para el pais ingresado.
sub solicitarSistema {
	my ($pregunta) = @_;
	my ($sistema);
	my ($salir) = "false";
	while ($salir eq "false") {
		print $pregunta;
		$sistema = <STDIN>;
		chop ($sistema);
		print "\nEl codigo del sistema ingresado es: $sistema \n";
		# Verifico que el sistema exista para el pais ingresado.
		my($existeSistema) = &verificarCodigoSistema($sistema);
		if ($existeSistema eq "true") {
			$salir = "true";
		}
	}
	return ($sistema);
}

# Se verifica si el ID del sistema ingresado se corresponde con el pais ingresado respecto al archivo P-S.mae, en su correspondiente $pathPS.
# Ademas, verifica que el sistema ingresado sean caracteres numericos.
# Recibe el sistema ingresado.
# Devuelve true o false en caso de que exista o no respectivamente.
sub verificarCodigoSistema {
	my ($sistema) = @_;
	my ($existeSistema) = "false";
	if ($sistema =~ /^[0-9]+$/ ) {
		open (PS, "<$pathPS") || die "ERROR: No se pudo abrir el archivo $pathPS \n";
		@lineaPS = <PS>;	
		foreach (@lineaPS) {
			if ($_ =~ /^$IDPais-[^-]+-$sistema-/ ) {
				$existeSistema = "true";
			}		
		};
		if ($existeSistema eq "false") {
			print "ERROR: El codigo de sistema ingresado no existe en los archivos maestros. \n";
		}
		close(PS);
	}
	else {
		print "ERROR: El sistema debe tener caracteres numericos. \n";
	}
	return($existeSistema);
}

# Ciclo donde se solicita al usuario ingresar el anio por el cual filtrar.
# En caso de ingresar un anio mayor que el actual, se seguira solicitando al usuario el ingreso del anio.
# Recibe la pregunta a realizar.
# Devuelve el anio ingresado.
# Se valida que el anio sea menor o igual al actual y mayor al 2000.
sub solicitarAnio {
	my ($pregunta) = @_;
	my ($anio);
	my ($salir) = "false";
	while ($salir eq "false") {
		print $pregunta;
		$anio = <STDIN>;
		chop ($anio);
		print "\nEl anio ingresado es: $anio \n";
		# Verifico que el anio sea menor o igual al actual y mayor al 2000.
		my ($existeAnio) = &verificarAnio($anio);
		if ($existeAnio eq "true") {
			$salir = "true";
		}
	}
	return ($anio);
}

# Verifica que el anio sea menor o igual al actual y mayor al 2000.
# Recibe el anio ingresado.
# Devuelve true o false si es valido o no respectivamente.
# Ademas, valida que el anio ingresado sean 4 caracteres numericos.
sub verificarAnio {
	my($anio) = @_;
	my($existeAnio) = "false";
	# Verifico que el anio ingresado sean solo numeros y cantidad 4.
	if ($anio =~ /^[0-9]{4}$/ ) {
		# Verifico que el anio ingresado es menor o igual que el actual.
		if ($anio > $anioActual) {
			print "ERROR: El anio ingresado es mayor que el anio actual. \n";
		}
		else {
			# Verifico que el anio ingresado es mayor al 2000. 
			if ($anio <= 2000) {
				print "ERROR: El anio ingresado es menor o igual al 2000. \n";
			}
			else {
				$existeAnio = "true";
			}	
		}
	}
	else {
		print "ERROR: El anio ingresado debe tener 4 caracteres numericos \n";
	}
	return($existeAnio);
}

# Ciclo donde se solicita al usuario ingresar el periodo por el cual filtrar.
# En caso de ingresar un periodo mayor que el actual, se seguira solicitando al usuario el ingreso del periodo.
# Recibe la pregunta a realizar.
# Devuelve el periodo ingresado.
# Se valida que el periodo sea menor o igual al actual.
sub solicitarPeriodo {
	my ($anioPeriodo, $mesPeriodo);
	my ($pregAnio, $pregMes) = @_;
	my ($salir) = "false";
	while ($salir eq "false") {
		$anioPeriodo = &solicitarAnio($pregAnio);
		$mesPeriodo = &solicitarMes($pregMes);	
		# Verifico que el periodo sea menor o igual al actual.
		my ($existePeriodo) = &verificarPeriodo($anioPeriodo, $mesPeriodo);
		if ($existePeriodo eq "true") {
			$salir = "true";
		}
	}
	return ($anioPeriodo, $mesPeriodo);
}

# Ciclo donde se solicita al usuario ingresar el mes por el cual filtrar.
# En caso de ingresar un mes mayor que 12 o menor que 1, se seguira solicitando al usuario el ingreso del mes.
# Recibe la pregunta a realizar.
# Devuelve el mes ingresado.
# Se valida que el mes ingresado exista con el hash %meses.
sub solicitarMes {
        my ($pregunta) = @_;
        my ($mes);
        my ($salir) = "false";
        while ($salir eq "false") {
                print $pregunta;
                $mes = <STDIN>;
                chop ($mes);
                print "\nEl mes ingresado es: $mes \n";
		# Verifico que exista el mes en el hash %meses.
		$mes = &convertirMes($mes);
        	# Verifico que el mes sea menor o igual que 12 y mayor o igual a 1.
	        my ($existeMes) = &verificarMes($mes);
                if ($existeMes eq "true") {
                        $salir = "true";
                }
        }
        return ($mes);
}

# Valida que el periodo ingresado sea menor o igual al actual. Se compara contra las variables globales del localtime.
# Recibe el periodo ingresado.
# Devuelve true o false si es valido o no respectivamente.
sub verificarPeriodo {
	my($anio, $mes) = @_;
	my($existePeriodo) = "false";
	# Caso: Anio < AnioActual		
	if ($anio < $anioActual) {
		$existePeriodo = "true";		
	}
	else {
		# Caso: Anio = Anio Actual
		# Comparo Meses. Caso Mes <= Mes Actual
		if ($mes <= $mesActual) {
			$existePeriodo = "true";
		}
		else {
			# Caso Mes > Mes Actual
			print "ERROR: El periodo ingresado es mayor al actual. \n";
		}
	}	
	return($existePeriodo);	
}

# Verifica que el mes sea menor o igual que 12 y mayor o igual a 1.
# Recibe el mes ingresado.
# Devuelve true o false si es valido o no respectivamente.
sub verificarMes {
	my ($mes) = @_;
	my ($existeMes) = "false";
	if ($mes ne "") {
		# Se verifica si el mes ingresado esta entre 1 y 12	
		if ( ($mes < 1) || ($mes > 12) ) {
			print "ERROR: El mes ingresado no se encuentra entre 1 y 12. \n";
		}
		else {
			$existeMes = "true";
		}
	}
	return ($existeMes);		
}

# Ciclo donde se solicita al usuario ingresar el rango de periodos por el cual filtrar.
# En caso de ingresar un periodo mayor que el actual, el periodo inicial mayor al final o no sea un rango, se seguira solicitando al usuario el ingreso del rango.
# Recibe las preguntas a realizar.
# Devuelve el rango de periodos ingresado.
# Se valida que no se ingrese un periodo mayor al actual, el periodo inicial mayor al final o no sea un rango (mes y anio iniciales y finales iguales).
sub solicitarRangoPeriodo {
	my ($pregAnioIni, $pregMesIni, $pregAnioFin, $pregMesFin) = @_;
	my ($anioRangoIni, $mesRangoIni, $anioRangoFin, $mesRangoFin);
	my ($salir) = "false";
	while ($salir eq "false") {
		($anioRangoIni, $mesRangoIni) = &solicitarPeriodo($pregAnioIni, $pregMesIni);
		($anioRangoFin, $mesRangoFin) = &solicitarPeriodo($pregAnioFin, $pregMesFin);
		# Verifico que no se ingrese un periodo mayor al actual, el periodo inicial mayor al final o no sea un rango (mes y anio iniciales y finales iguales). 
		my ($existeRango) = &verificarRango($anioRangoIni, $mesRangoIni, $anioRangoFin, $mesRangoFin);
		if ($existeRango eq "true") {
			$salir = "true";
		}
	}
	return ($anioRangoIni, $mesRangoIni, $anioRangoFin, $mesRangoFin);
}

# Convierte y valida el nombre del mes o numero de mes con el hash %meses. De nombre a numero y de numero a mismo numero.
# Recibe el nombre o numero del mes ingresado.
# Devuelve el numero de mes o una cadena vacia en caso de no existir el mes.
sub convertirMes {
        my ($mes) = @_;
        $mes = lc ($mes);
        $mes =~ s|setiembre|septiembre|;
	$mes = &octalADecimal($mes);
        if (exists($meses{$mes})) {
                $mes = $meses{$mes};
        }
        else {
                print "ERROR: El mes ingresado no existe. \n";
                $mes = "";
        }
        return($mes);
}

# Valida que los periodos ingresados sean menor o igual al actual, el periodo inicial sea menor al final y que ambos periodos no sean iguales. Se compara contra las variables globales del localtime.
# Recibe el rango de periodos ingresado.
# Devuelve true o false si es valido o no respectivamente.
sub verificarRango {
	my($anioIni, $mesIni, $anioFin, $mesFin) = @_;
	my($existeRango) = "false";
	# Caso: Anio Inicial < Anio Final
	if ($anioIni < $anioFin) {
		$existeRango = "true";
	}
	else {
		# Caso: Anio Inicial = Anio Final		
		if ($anioIni == $anioFin) {
			# Comparo los meses. Caso: Mes Inicial < Mes Final
			if ($mesIni < $mesFin) {
				$existeRango = "true";
			}
			else {
				# Comparo los meses. Caso: Mes Inicial = Mes Final
				if ($mesIni == $mesFin) {
					print "ERROR: El rango ingresado es un periodo, anio y mes iguales. \n";
				}
				else {
					# Caso: Mes Inicial > Mes Final
					print "ERROR: El mes inicial ingresado es mayor que el mes final. \n";
				}
			}
		}
		else {
			# Caso: Anio Inicial > Anio Final
			print "ERROR: El anio inicial ingresado es mayor que el anio final. \n";
		}
	}
	return ($existeRango);
}

# Ciclo donde se solicita al usuario ingresar la consulta a realizar.
# En las consultas "diferencias", en caso de ingresar un valor menor o igual que 0, se seguira solicitando al usuario el ingreso del valor.
# NO recibe parametros.
# Devuelve la opcion de la consulta y el valor ingresados.
# Se valida que el valor ingresado sea mayor que 0. 
sub solicitarConsulta {
	my ($opcion);
	my ($salir) = "false";
	while ($salir eq "false") {	
		print "A continuacion se enunciaran las posibles consultas: \n";
		print "	a) Comparacion para el recalculo. \n";
		print "	b) Diferencia (en valor absoluto) mayor al x%. \n";
		print "	c) Diferencia (en valor absoluto) mayor al x (en pesos). \n";
		print "Ingrese la consulta elegida (a-b-c): ";
		$opcion = <STDIN>;
		chop($opcion);
		print "\nLa opcion ingresada es: $opcion \n";
		if ($opcion eq "a" || $opcion eq "A" || $opcion eq "b" || $opcion eq "B" || $opcion eq "c" || $opcion eq "C") {
			$opcion = lc ($opcion);
			$salir = "true";
		}
		else {
			print "Opcion de consulta incorrecta. \n";		
		}
	}
	if ($opcion eq "b" || $opcion eq "c") {
		my ($salirX) = "false";
		while ($salirX eq "false") {
			if ($opcion eq "b") {
				print "Ingrese el valor x%: ";
			}
			else {
				print "Ingrese el valor x (en pesos): ";
			}
			$valor = <STDIN>;
			chop($valor);
			print "\nEl valor ingresado es: $valor \n";
			if ($valor > 0) {
				$salirX = "true";
			}
			else {
				print "ERROR: El valor X debe ser positivo. \n";			
			}
		}
	}
	else {
		$valor = "invalido";	
	}
	return ($opcion,$valor);
}

# Realiza el filtrado de los registros del maestro segun los filtros ingresados, y la correspondencia con los registros de PRESTAMOS.<pais>.
# NO recibe NI devuelve nada.
# Los registros se almacenan en el hash global %regs. Clave => registro del maestro. Valor => registro de PRESTAMOS.<pais>.
sub filtrar {
	my (@regMae) = &filtrarMaestro;
	@regs{ @regMae } = "".."";
	&filtrarPrestamos;
}

# Filtra del archivo maestro PPI.mae (pathPPI), los registros correspondientes al pais ingresado y segun los filtros seleccionados.
# NO recibe nada.
# Devuelve un vector con todos los registros filtrados.
sub filtrarMaestro {
	my (@reg, @regMae, $cumpleSistema, $cumpleAnio, $cumplePeriodo, $cumpleRango);
	open (MAESTRO, "<$pathPPI") || die "ERROR: No se pudo abrir el archivo $pathPPI \n";
	# En cada linea del archivo maestro, aplico los filtros seleccionados.
	while (<MAESTRO>) {
		chomp($_);
		# Filtro por pais.
		if ($_ =~ /^$IDPais;/) {
			# Si se seleccionaron filtros.
			if (%filtros) {
				$cumpleSistema = "false";
				$cumpleAnio = "false";
				$cumplePeriodo = "false";
				$cumpleRango = "false";

				@reg = split (";", $_);
				# Paso a 1..9 los meses, en caso que esten 01..09.
				@reg[3] = &octalADecimal($reg[3]);

				# SI EXISTE EL FILTRO, LA UNICA FORMA DE QUE CUMPLIR=TRUE ES QUE CUMPLA EL FILTRO.

				# Si existe filtro por sistema, filtro.
				if (exists ($filtros{"ID_Sistema"})) {
					if (($reg[1] <=> $filtros{"ID_Sistema"}) == 0) {
						$cumpleSistema = "true";
					}
				} 
				else {
					$cumpleSistema = "true";
				}
				# Si existe filtro por anio, filtro.
				if (exists ($filtros{"Anio"})) {
					if (($reg[2] <=> $filtros{"Anio"}) == 0) {
						$cumpleAnio = "true";
					}
				} 
				else {
					$cumpleAnio = "true";
				}
				# Si existe filtro por periodo, filtro.
				if (exists ($filtros{"Anio_de_Periodo"})) {
					if ( (($reg[2] <=> $filtros{"Anio_de_Periodo"}) == 0) && (($reg[3] <=> $filtros{"Mes_de_Periodo"}) == 0) ) {
						$cumplePeriodo = "true";
					}
				} 
				else {
					$cumplePeriodo = "true";
				}
				# Si existe filtro por rango de periodos, filtro.
				if (exists ($filtros{"Anio_Inicial_de_Rango_de_Periodos"})) {
					# Caso: Anio > AnioInicial y Anio < AnioFinal			
					if ((($reg[2] <=> $filtros{"Anio_Inicial_de_Rango_de_Periodos"}) == 1) && (($reg[2] <=> $filtros{"Anio_Final_de_Rango_de_Periodos"}) == -1)) {
						$cumpleRango = "true";
					}
					else {
						# Caso: Anio = AnioInicial y Anio < AnioFinal
						if ((($reg[2] <=> $filtros{"Anio_Inicial_de_Rango_de_Periodos"}) == 0) && (($reg[2] <=> $filtros{"Anio_Final_de_Rango_de_Periodos"}) == -1)) {
							# Comparo los meses del inicial.
							# Caso: Mes > MesInicial o Mes = MesInicial
							if ((($reg[3] <=> $filtros{"Mes_Inicial_de_Rango_de_Periodos"}) == 1) || (($reg[3] <=> $filtros{"Mes_Inicial_de_Rango_de_Periodos"}) == 0)){
								$cumpleRango = "true";
							}
						}				
						else {
							# Caso: Anio > AnioInicial y Anio = AnioFinal
							if ((($reg[2] <=> $filtros{"Anio_Inicial_de_Rango_de_Periodos"}) == 1) && (($reg[2] <=> $filtros{"Anio_Final_de_Rango_de_Periodos"}) == 0)) {
								# Comparo los meses del final.
								# Caso: Mes < MesFinal o Mes = MesFinal
								if ((($reg[3] <=> $filtros{"Mes_Final_de_Rango_de_Periodos"}) == -1) || (($reg[3] <=> $filtros{"Mes_Final_de_Rango_de_Periodos"}) == 0)){
									$cumpleRango = "true";
								}
							}
							else {
								# Caso: Anio = AnioInicial y Anio = AnioFinal
								if ((($reg[2] <=> $filtros{"Anio_Inicial_de_Rango_de_Periodos"}) == 0) && (($reg[2] <=> $filtros{"Anio_Final_de_Rango_de_Periodos"}) == 0)){
									# Comparo los meses del inicial y el final.
									# Caso: (Mes > MesInicial o Mes = MesInicial) y (Mes < MesFinal o Mes = MesFinal)
									if ( ((($reg[3] <=> $filtros{"Mes_Inicial_de_Rango_de_Periodos"}) == 1) || 
										(($reg[3] <=> $filtros{"Mes_Inicial_de_Rango_de_Periodos"}) == 0)) &&
										((($reg[3] <=> $filtros{"Mes_Final_de_Rango_de_Periodos"}) == -1) || 
										(($reg[3] <=> $filtros{"Mes_Final_de_Rango_de_Periodos"}) == 0)) ) {
											$cumpleRango = "true";
									}
								}						
							}				
						}
					}
				} 
				else { 
					$cumpleRango = "true"
				}
				# Lo agrego si EXISTE Y CUMPLE los filtros. Solo falla si EXISTE Y NO CUMPLE. 
				if (($cumpleSistema eq "true") && ($cumpleAnio eq "true") && ($cumplePeriodo eq "true") && ($cumpleRango eq "true")) {
					push(@regMae,$_);
				}
			}
			# Si no se seleccionaron filtros, lo agrego ya que cumple con pais.
			else {
				push(@regMae, $_);
			}			
		}
	} 
	close (MAESTRO);
	return (@regMae);
}

# Pasa dia o mes de octal a decimal, en caso de [1..9]. Ej: si se pasa por parametro 02, se estandariza a 2.
# Recibe el dia o mes.
# Devuelve el dia o mes con un solo digito en caso de que el 1ero sea 0.
sub octalADecimal {
	my($mes) = @_;
	if ((length($mes) == 2) && (substr($mes,0,1) eq "0")) {
		$mes = substr($mes,1,2);
	}
	return ($mes);
}

# Pasa dia o mes de decimal a octal, en caso de [1..9]. Ej: si se pasa por parametro 2, se estandariza a 02.
# Recibe el dia o mes.
# Devuelve el dia o mes con dos digitos en caso de [1..9].
sub decimalAOctal {
	my($mes) = @_;
	if (length($mes) == 1) {
		$mes = "0" . $mes;
	}
	return ($mes);
}

sub filtrarPrestamos {
	open (PRESTAMOS, "<$pathPrestamos") || die "ERROR: No se pudo abrir el archivo $pathPrestamos \n";
	# En cada registro filtrado del maestro, busco los registros de prestamos.<pais>
	foreach my $clave(keys(%regs)) {
		my (@regMae) = split(";", $clave);
		my ($codMae) = $regMae[7];
		my ($anioMae) = $regMae[2];
		my ($mesMae) = $regMae[3];

		# Paso de 1..9 a 01..09 los meses, ya que en <PRESTAMOS> esta como 01..09
		$mesMae = &decimalAOctal($mesMae);
		# En cada linea del archivo prestamos.<pais>, filtro con los registros filtrados del maestro.
		my (@regsPres) = grep { /^[^;]+;$anioMae;$mesMae;[^;]+;[^;]+;$codMae;/ } <PRESTAMOS>;
		
		# Caso: no encontro ninguna coincidencia, por lo tanto, elimino el registro del maestro del hash.
		if ($#regsPres == -1) {
			delete(@regs{$clave});
		}
		else {
			# Caso: encontro solo una coincidencia, por lo tanto, se asigna al registro del maestro.
			if ($#regsPres == 0) {
				@regs{$clave} = $regsPres[0];
			}
			else {
				# Caso: encontro muchas coincidencias.
				# Me quedo con el de mayor dia contable.
				my ($diaPres) = 0;
				foreach my $regPres (@regsPres) {
					my (@reg) = split(";", $regPres);
					if ($diaPres < $reg[3]) {
						$diaPres = $reg[3];
					}
				};
				# Paso a 1..9 los dias, en caso que esten 01..09.	
				$diaPres = &octalADecimal($diaPres);
       				@regsPres = grep { /^[^;]+;$anioMae;$mesMae;$diaPres;[^;]+;$codMae;/ } @regsPres;
				# Caso: encontro solo una coincidencia.
				if ($#regsPres == 0) {
					@regs{$clave} = $regsPres[0];
				}
				else {
					# Caso: encontro muchas coincidencias.
					# Me quedo con el de mayor fecha de grabacion.
					my ($fecha) = "0/0/0";
					foreach my $regPresF (@regsPres) {
						my (@reg) = split(";", $regPresF);
						if (&compararFechas($fecha,$reg[14]) == 1) {
							$fecha = $reg[14];
						}
					};
					@regsPres = grep { /;$fecha;[^;]+$/ } @regsPres; 
					# Caso: encontro solo una coincidencia, por lo tanto, se asigna al registro del maestro.
		                        if ($#regsPres == 0) {
                		                @regs{$clave} = $regsPres[0];
					}
 					else {
						print "ERROR: Existen varios registros con la fecha de grabacion $fecha respecto al registro maestro $clave\n";
						print "Para la comparacion se selecciono el ultimo.\n";
						@regs{$clave} = $regsPres[$#regsPres];
					}
				}		
			}		
		}
		@regsPres = ();
		seek (PRESTAMOS, 0, 0);
	};	
	close(PRESTAMOS);
}

# Compara fechas. Solo interesa el caso en que fecha1 < fecha2. Si sucede, devuelve 1. Otro caso, devuelve 0.
# Recibe las fechas a comparar.
# Devuelve 1 si el 1er parametro es menor al 2do parametro. En otro caso, devuelve 0.
sub compararFechas {
	my($fecha1,$fecha2) = @_;
	my ($resul) = 0;
	my (@fec1) = split('/',$fecha1);
	my (@fec2) = split('/',$fecha2);
	# Comparo por anio
	# Caso: anio1 < anio2
	if ($fec1[2] < $fec2[2]) {
		$resul = 1;
	}
	else {
		# Caso anio1 = anio2	
		if ($fec1[2] == $fec2[2]) {
			# Comparo por mes
			# Caso: mes1 < mes2
			if ($fec1[1] < $fec2[1]) {
				$resul = 1;
			}
			else {
				# Caso: mes1 = mes2
				if ($fec1[1] == $fec2[1]) {
					# Comparo por dia
					# Caso: dia1 < dia2
					if ($fec1[0] < $fec2[0]) {
						$resul = 1;
					}
				}
			}
		}
	}
	return ($resul);
}

# Calcula los montos restantes de los registros filtrados del maestro o de PRESTAMOS.<pais>. Obtiene los registros del hash global %regs.
# Recibe el tipo de registro. Puede ser "maestro" o "prestamos".
# Devuelve un vector con todos los montos restantes calculados.
sub calcularMontosRestantes {
	my ($tipo) = @_;
	my (@montos) = ();
	my (@regsMy);

	# Selecciono claves o valores segun el tipo de registro.
	if ($tipo eq "maestro") {
		@regsMy = keys(%regs);
	}
	else {
		@regsMy = values(%regs);
	}
	# Por cada registro, calculo el monto restante. En el maestro, segun la formula. En el PRESTAMOS.<pais> esta calculado en el campo nro 11.
	# Se reemplaza el separador decimal "," por el "." para realizar la cuenta, en el caso que corresponda.
	foreach (@regsMy) {
		my (@reg) = split(";", $_);
		if ($tipo eq "maestro") {
			chomp($reg[13]);
			push(@montos, comaXPunto($reg[9]) + comaXPunto($reg[10]) + comaXPunto($reg[11]) + comaXPunto($reg[12]) - comaXPunto($reg[13]));
		}
		else {	
			push(@montos, comaXPunto($reg[11]));
		}
	};
	return (@montos);
}

# Reemplaza las "," por "."
# Recibe un numero real.
# Devuelve un numero real con el separador decimal "."
sub comaXPunto {
	my ($nro) = @_;
	$nro =~ s/,/./g;
	return ($nro);
}

# Reemplaza los "." por ","
# Recibe un numero real.
# Devuelve un numero real con el separador decimal ","
sub puntoXComa {
	my ($nro) = @_;
	$nro =~ tr/'.'/,/;
	return ($nro);
}

# Obtiene los codigos de prestamo de los registros de PRESTAMOS.<pais> filtrados. Se accede a traves de los valores de %regs.
# NO recibe parametros.
# Devuelve un vector con todos los codigos de prestamo correspondientes a los registros filtrados.
sub obtenerCodigoPrestamo {
	my (@codPres, @reg);
	my (@regsRef) = values(%regs);
	# Por cada registro filtrado, obtengo el codigo de prestamo que se encuentra en el campo nro 5.
	foreach (@regsRef) {
		@reg = split(";", $_);
		push(@codPres, $reg[5]);
	};
	return (@codPres);
}

# Realiza la consulta "Comparacion para el recalculo". Compara y muestra resultados. Pregunta si el usuario desea grabar RECALCULO.<pais>. En caso afirmativo, graba.
# NO recibe NI devuelve nada.
# Los datos necesarios los obtiene del hash %regs, donde por cada clave=regMaestro, tengo un array de la forma (regPrestamos, montoMae, montoPres, codPres).
# Imprime los filtros, la consulta seleccionada y los resultados de la comparacion. Pregunta si desea grabar RECALCULO.<pais>. En caso afirmativo, graba.
sub recalculo {
	my ($i) = 0;
	foreach my $regMae (keys(%regs)) {
		my (@regM) = split(";",$regMae);
		my (@regP) = split(";",$regs{$regMae}[0]);
		# @vector = (regPrestamos, PRES_ID, PRES_CLI_ID, CTB_ESTADO Mae, CTB_ESTADO Pres, montoMae, montoPres) 
		my (@vector) = ($regs{$regMae}[0], $regP[5], $regP[12], $regM[5], $regP[4], $regs{$regMae}[1], $regs{$regMae}[2]);

		# Comparo estados contables y montos restantes.
		if ( (($regM[5] eq "SMOR") && ($regP[4] ne "SMOR")) || ($regs{$regMae}[1] < $regs{$regMae}[2])) {
			push (@vector, "RECALCULO"); 
		}
		else {
			push (@vector, "BUENO");
		}
		@regsRecalculo{$regMae} = [@vector];
		$i++;
	}
	&imprimirConsultaYFiltros("recalculo");
	&imprimirTitulosRecalculo;
	&imprimirResultadosRecalculo;
	print "Se listaron $i registros. \n";

	# Consulto si desea imprimir Recalculo
	my ($pregGrabarRec) = "¿Desea grabar RECALCULO? (S-N): ";
	my ($opcion) = &cicloSiNo ($pregGrabarRec);
	if ($opcion eq "s") {
		&imprimirRecalculoEnArchivo;
	}
}

# Imprime los titulos para mostrar los resultados de recalculo en columnas.
# NO recibe NI devuelve nada.
sub imprimirTitulosRecalculo {
	printf ("%14s", "Cod_Prestamo");
        print "  ";
	printf ("%12s", "Cod_Cliente");
        print "  ";
	printf ("%14s", "EC_Maestro");
        print "  ";
        printf ("%10s", "EC_Pais");
        print "  ";
        printf ("%14s", "MR_Maestro");
        print "  ";
        printf ("%12s", "MR_Pais");
        print "  ";
        print "Recomendacion\n";
}

# Imprime los resultados de recalculo en columnas. Obtiene los datos necesarios del hash global %regsRecalculo.
# NO recibe NI devuelve nada.
sub imprimirResultadosRecalculo {
	# Formato: (regPrestamos, PRES_ID, PRES_CLI_ID, CTB_ESTADO Mae, CTB_ESTADO Pres, montoMae, montoPres, recomendacion) 
	foreach my $clave (keys(%regsRecalculo)) {
		printf ("%14s", $regsRecalculo{$clave}[1]);
        	print '  ';
	        printf ("%12s", $regsRecalculo{$clave}[2]);
        	print '  ';
	        printf ("%14s", $regsRecalculo{$clave}[3]);
		print '  ';
                printf ("%10s", $regsRecalculo{$clave}[4]);
		print '  ';
                printf ("%14s", '$' . $regsRecalculo{$clave}[5]);
		print '  ';
                printf ("%12s", '$' . $regsRecalculo{$clave}[6]);
               	print '  ';
                printf ("%13s", $regsRecalculo{$clave}[7]);
		print "\n";
        }
}

# Imprime los resultados de recalculo en el archivo RECALCULO.<pais> con el formato correspondiente. Obtiene los datos necesarios del hash global %regsRecalculo.
# NO recibe NI devuelve nada.
sub imprimirRecalculoEnArchivo {
	# Paso el dia y mes actual a formato 01..09.
	my ($dia) = &decimalAOctal($diaActual);
	my ($mes) = &decimalAOctal($mesActual);

	# Armo la fechaGrab con la fecha actual en formato dd/mm/aaaa.
	my (@fecha) = ($dia, $mes, $anioActual);
	my ($fechaGrab) = join ("/", @fecha);

	# Obtengo el nombre del usuario.
	my ($user) = getlogin();

	$pathRecalculo = $ENV{REPODIR} . "/RECALCULO." . $IDPais;
	
	open (SALIDA, ">>$pathRecalculo") || open (SALIDA, ">$pathRecalculo") || die "ERROR: No se pudo abrir el archivo $pathRecalculo \n";
	foreach my $clave (keys(%regsRecalculo)) { 	
		my (@regM) = split (";", $clave);
		my (@regP) = split (";", $regsRecalculo{$clave}[0]);
		# Formato:SIS_ID;CTB_ANIO;CTB_MES;CTB_DIA;CTB_ESTADO;PRES_ID;PRES_CLI_ID;PRES_CLI;MT_PRES;MT_IMPAGO;MT_INDE;MT_INNODE;MT_DEB;MT_REST;INS_FE;INS_USER
		my (@vector) = ($regM[1], $regM[2], $regM[3], $regP[3], $regM[5], $regM[7], $regP[12], $regP[13], $regM[9], $regM[10], $regM[11], $regM[12]);
		chomp($regM[13]);
		@vector = (@vector, $regM[13], puntoXComa($regsRecalculo{$clave}[5]), $fechaGrab, $user);
		print SALIDA join (";",@vector) . "\n";
	}
	close (SALIDA);
}

# Imprime los resultados de diferencia por porcentaje en columnas. Obtiene los datos necesarios del hash global %regs.
# Recibe el valor ingresado.
# NO devuelve nada.
sub difPorcentaje {
	my ($valor) = @_;
	my ($cant) = 0;
	&imprimirConsultaYFiltros("porcentaje", $valor);
	&imprimirTitulos;
#	my ($MRMae) = sprintf("%.2f", $regs{$clave}[1]);
#	my ($MRPres) = sprintf("%.2f", $regs{$clave}[2]);
	foreach my $clave (keys(%regs)) {
		my ($dif) = (1-($regs{$clave}[2]/$regs{$clave}[1]))*100;
		if (abs($dif) > $valor) {
			&imprimirResultado("porcentaje", $regs{$clave}[3], $regs{$clave}[1], $regs{$clave}[2], $dif);
			$cant++;
		}
	}
	print "Se listaron $cant registros. \n";
}

# Imprime los resultados de diferencia por monto en columnas. Obtiene los datos necesarios del hash global %regs.
# Recibe el valor ingresado.
# NO devuelve nada.
sub difMonto {
	my ($valor) = @_;
	my ($cant) = 0;
	&imprimirConsultaYFiltros("monto", $valor);
	&imprimirTitulos;
	foreach my $clave (keys(%regs)) {
		my ($dif) = $regs{$clave}[1] - $regs{$clave}[2];
		if (abs($dif) > $valor) {
			&imprimirResultado("monto", $regs{$clave}[3], $regs{$clave}[1], $regs{$clave}[2], $dif);
			$cant++;
		}
	}
	print "Se listaron $cant registros. \n";
}

# Imprime la consulta y los filtros. 
# Recibe el tipo de consulta: "recalculo", "porcentaje" o "monto" y el valor ingresado.
# NO devuelve nada.
sub imprimirConsultaYFiltros {
	my ($tipo, $valor) = @_;
	if ($tipo eq "recalculo") {
		print "Se consulto por Comparacion para el recalculo \n";		
	}
	else {
		if ($tipo eq "porcentaje") {
			print "Se consulto por Diferencia (en valor absoluto) mayor al X % \n";
			print "X = " . $valor . ' % ' . "\n";
		}
		else {
			# $tipo eq "monto"
			print "Se consulto por Diferencia (en valor absoluto) mayor al X (en pesos) \n";
			print 'X = $ ' . $valor . "\n";
		}
	}
	&imprimirFiltros;
}

# Imprime los filtros seleccionados.
# NO recibe NI devuelve nada.
sub imprimirFiltros {
	if (%filtros) {
		print "Los filtros aplicados en la consulta son los siguientes:\n";
		foreach my $clave (keys(%filtros)) {
			print "Filtro aplicado: " . $clave . " => " . $filtros{$clave} . "\n";
		};
	}
	else {
		print "No se aplicaron filtros en la consulta.\n";
	}
}

# Imprime los titulos para mostrar los resultados de diferencia por porcentaje o por monto en columnas.
# NO recibe NI devuelve nada.
sub imprimirTitulos {
	printf ("%12s", "Cod_Prestamo");
	print "  ";
	printf ("%14s", "MR_Maestro");
	print "  ";
	printf ("%14s", "MR_Pais");
	print "    ";
	print "Diferencia\n";
}

# Imprime los resultados de diferencia por porcentaje o por monto en columnas.
# Recibe el tipo de consulta: "porcentaje" o "monto", codPres, montoMae, montoPres, diferencia. 
# NO devuelve nada.

sub imprimirResultado {
	my ($tipo, $codPres, $montoMae, $montoPres, $dif) = @_;
	printf ("%12s", $codPres);
	print '  ';
	printf ("%14s", '$' . $montoMae);
	print '  ';
	printf ("%14s", '$' . $montoPres);
	if ($tipo eq "monto") {
		print '  ';
		printf ("%12s", '$' . sprintf("%.2f", $dif));
		print "\n";
	}
	else {
		print "  ";
		printf ("%11s", sprintf("%.2f", $dif));
		print "% \n";
	}
}

1;  # Retornar un valor de `verdad'
